const express = require('express');
const router = express.Router();

const ListingPrisma = require('../models/ListingPrisma');
const UserPrisma = require('../models/UserPrisma');
const { authenticateToken, requireActive, requireCredits, optionalAuth } = require('../middleware/auth');
const ResponseHelper = require('../utils/response');
const Validator = require('../utils/validator');
const { workingTimeHelper } = require('../utils/workingTime');
const { getDayRange, isLimitReached } = require('../utils/publishLimitHelper');

/**
 * 接口 4: 发布新信息
 * POST /api/v1/listings
 * 
 * 逻辑: 使用 JWT 中间件。接收小程序表单提交的所有公司信息。校验数据合法性
 * 数据库: 在 listings 表中插入一条新数据，user_id 从 JWT 中获取
 * 输出: 成功创建的消息
 */
router.post('/', authenticateToken, requireActive, requireCredits, async (req, res) => {
  try {
    const userId = req.user.id;
    const listingData = { ...req.body, user_id: userId };

    // 验证数据
    const errors = Validator.validateListingData(listingData);
    if (errors.length > 0) {
      return ResponseHelper.validationError(res, errors);
    }

    const now = new Date();
    const { startOfDay, endOfDay } = getDayRange(now);
    const todayPublishCount = await ListingPrisma.countUserListingsInRange(userId, startOfDay, endOfDay);

    if (isLimitReached(todayPublishCount)) {
      return ResponseHelper.forbidden(res, '今天的发布次数已到达上限');
    }

    // 判断当前是否为工作时间
    const isWorkingTime = workingTimeHelper.isWorkingTime(now);

    // 根据工作时间设置审核策略
    // 所有提交的信息都设置30分钟后自动发布，确保自动上架功能正常工作
    listingData.audit_status = 'PENDING';
    listingData.status = 'OFF_SHELF'; // 待审核状态下先下架
    listingData.auto_publish_at = workingTimeHelper.calculateAutoPublishTime(now);

    // 注：工作时间和非工作时间都设置auto_publish_at，统一由定时任务处理
    // 如果管理员在30分钟内审核，则auto_publish_at会被清除；否则定时任务会自动上架

    // 创建挂牌信息
    const listing = await ListingPrisma.create(listingData);

    // 减少用户发布额度
    await UserPrisma.reduceCredits(userId, 1);

    // 返回统一的提示信息
    const autoPublishTime = workingTimeHelper.calculateAutoPublishTime(now);
    const message = `发布成功，信息已提交审核。如30分钟内（${autoPublishTime.toLocaleTimeString('zh-CN')}）管理员未审核将自动上架`;

    ResponseHelper.success(res, listing.toJSON(), message, 201);

  } catch (error) {
    console.error('发布信息错误:', error);

    if (error.message === '发布额度不足') {
      return ResponseHelper.forbidden(res, '发布额度不足，请购买套餐');
    }

    ResponseHelper.serverError(res, '发布失败', error);
  }
});

/**
 * 接口 5: 获取信息列表
 * GET /api/v1/listings
 * 
 * 逻辑: 无需登录即可访问。实现分页功能 (输入 page, pageSize)。按创建时间降序排序
 * 输出: 分页后的信息列表及总条数
 */
router.get('/', optionalAuth, async (req, res) => {
  try {
    // 验证分页参数
    const { page, pageSize } = Validator.validatePagination(req.query);
    
    // 获取筛选参数
    const {
      status = '在售',
      listing_type,
      registration_province,
      registration_city,
      company_type,
      tax_status,
      search
    } = req.query;

    const options = {
      page,
      pageSize,
      status,
      listing_type,
      registration_province,
      registration_city,
      company_type,
      tax_status,
      search
    };

    // 获取信息列表
    const result = await ListingPrisma.getList(options);

    ResponseHelper.paginated(
      res,
      result.data.map(listing => listing.toJSON()),
      result.pagination,
      '获取信息列表成功'
    );

  } catch (error) {
    console.error('获取信息列表错误:', error);
    ResponseHelper.serverError(res, '获取信息列表失败', error);
  }
});

/**
 * 接口 6: 获取信息详情
 * GET /api/v1/listings/:id
 * 
 * 逻辑: 根据传入的 id，查询 listings 表，并关联查询发布者的部分信息（如昵称）
 * 输出: 完整的单条信息详情
 */
router.get('/:id', optionalAuth, async (req, res) => {
  try {
    const { id } = req.params;

    // 验证ID格式
    if (!id || isNaN(parseInt(id))) {
      return ResponseHelper.validationError(res, ['无效的信息ID']);
    }

    // 获取信息详情
    const listing = await ListingPrisma.findById(parseInt(id));
    
    if (!listing) {
      return ResponseHelper.notFound(res, '信息不存在');
    }

    ResponseHelper.success(res, listing.toJSON(), '获取信息详情成功');

  } catch (error) {
    console.error('获取信息详情错误:', error);
    ResponseHelper.serverError(res, '获取信息详情失败', error);
  }
});

/**
 * 更新挂牌信息
 * PUT /api/v1/listings/:id
 */
router.put('/:id', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const userId = req.user.id;

    // 验证ID格式
    if (!id || isNaN(parseInt(id))) {
      return ResponseHelper.validationError(res, ['无效的信息ID']);
    }

    // 查找信息
    const listing = await ListingPrisma.findById(parseInt(id));
    if (!listing) {
      return ResponseHelper.notFound(res, '信息不存在');
    }

    // 检查权限（只能修改自己发布的信息）
    if (listing.user_id !== userId) {
      return ResponseHelper.forbidden(res, '只能修改自己发布的信息');
    }

    // 检查已售状态的商品不能被编辑
    if (listing.status === 'SOLD') {
      return ResponseHelper.forbidden(res, '已售商品无法编辑');
    }

    // 检查普通用户不能直接修改状态为"在售"
    if (req.body.status === 'ON_SALE' && listing.audit_status === 'PENDING') {
      return ResponseHelper.forbidden(res, '待审核信息不能直接上架，请等待管理员审核或自动审核通过');
    }

    // 验证更新数据
    const errors = Validator.validateListingData(req.body, true);
    if (errors.length > 0) {
      return ResponseHelper.validationError(res, errors);
    }

    // 处理用户主动下架的情况
    const updateData = { ...req.body };
    if (req.body.status === '下架' && listing.audit_status === 'PENDING') {
      // 用户主动下架待审核的信息，设置特殊标记
      updateData.audit_comment = 'USER_OFFLINE';
    }

    // 更新信息
    const updatedListing = await ListingPrisma.update(parseInt(id), updateData);

    ResponseHelper.success(res, updatedListing.toJSON(), '更新成功');

  } catch (error) {
    console.error('更新信息错误:', error);
    ResponseHelper.serverError(res, '更新失败', error);
  }
});

/**
 * 重新提交审核
 * POST /api/v1/listings/:id/resubmit-audit
 */
router.post('/:id/resubmit-audit', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const userId = req.user.id;

    // 验证ID格式
    if (!id || isNaN(parseInt(id))) {
      return ResponseHelper.validationError(res, ['无效的信息ID']);
    }

    // 查找信息
    const listing = await ListingPrisma.findById(parseInt(id));
    if (!listing) {
      return ResponseHelper.notFound(res, '信息不存在');
    }

    // 检查权限（只能操作自己发布的信息）
    if (listing.user_id !== userId) {
      return ResponseHelper.forbidden(res, '只能操作自己发布的信息');
    }

    // 只有被拒绝的信息可以重新提交审核
    if (listing.audit_status !== 'REJECTED') {
      return ResponseHelper.error(res, '只有被拒绝的信息可以重新提交审核', 400);
    }

    // 重置审核状态，等待管理员手动审核（不设置自动发布时间）
    const updateData = {
      audit_status: 'PENDING',
      audit_comment: null,
      audit_time: null,
      auto_publish_at: null // 不设置自动发布，需要管理员手动审核
    };

    const updatedListing = await ListingPrisma.update(parseInt(id), updateData);

    ResponseHelper.success(res, updatedListing.toJSON(), '已重新提交审核，等待管理员审核');

  } catch (error) {
    console.error('重新提交审核错误:', error);
    ResponseHelper.serverError(res, '重新提交审核失败', error);
  }
});

/**
 * 删除挂牌信息
 * DELETE /api/v1/listings/:id
 */
router.delete('/:id', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const userId = req.user.id;

    // 验证ID格式
    if (!id || isNaN(parseInt(id))) {
      return ResponseHelper.validationError(res, ['无效的信息ID']);
    }

    // 查找信息
    const listing = await ListingPrisma.findById(parseInt(id));
    if (!listing) {
      return ResponseHelper.notFound(res, '信息不存在');
    }

    // 检查权限（只能删除自己发布的信息）
    if (listing.user_id !== userId) {
      return ResponseHelper.forbidden(res, '只能删除自己发布的信息');
    }

    // 删除信息
    const deleted = await ListingPrisma.delete(parseInt(id));
    
    if (deleted) {
      ResponseHelper.success(res, null, '删除成功');
    } else {
      ResponseHelper.error(res, '删除失败', 500);
    }

  } catch (error) {
    console.error('删除信息错误:', error);
    ResponseHelper.serverError(res, '删除失败', error);
  }
});

/**
 * 获取挂牌信息统计
 * GET /api/v1/listings/stats
 */
router.get('/stats', async (req, res) => {
  try {
    const stats = await ListingPrisma.getStats();
    ResponseHelper.success(res, stats, '获取统计信息成功');
  } catch (error) {
    console.error('获取统计信息错误:', error);
    ResponseHelper.serverError(res, '获取统计信息失败', error);
  }
});

module.exports = router;
